import com.sun.org.apache.regexp.internal.RE;

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

public class Solution {


    /**
     * cq
     * @param args
     */
    public static void main(String[] args) {
        //#-------------------------------- 返回数组两个数的和为目标数的下标(数组中不存在重复元素)
//        Integer[] nums = new Integer[]{1,5,8,10,12,8};
//        Integer target = 13;
//        Integer[] renums =   twoNums(nums, target);
//        for (Integer integer : renums){
//            System.out.println(integer);
//        }
        //#------------------------------------返回字符串最长子串的长度
        //System.out.println(lengthOfLongestSubstring("pwwkeyxab856w"));

        //#-----------------------------------返回字符串中最长子串
       // System.out.println(StringSubtring("pwwkeyxab856w"));

        //#-----------------------------------给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
        //System.out.println(reverseInteger(-234534324));

        //#-----------------------------------给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false
        //System.out.println(palindromeInteger(1221));

        //#-----------------------------------罗马数字转整数
        System.out.println(romanNumerals("IV"));


    }
    /**
     * 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那两个整数，并返回它们的数组下标。
     * 可以假设每对种输入只会应一个答案。但是，数组中同一个元素在答案里不能重复出现。
     * @param nums
     * @param target
     * @return
     */
    public static Integer[] twoNums(Integer[] nums, Integer target){
//        //暴力枚举
//        for (int i = 0; i < nums.length; ++i){
//            for (int j = i+1; j < nums.length; ++j){
//                if (nums[i] + nums[j] == target) {
//                    return  new Integer[]{i,j};
//                }
//            }
//        }
        //哈希表
        Map<Integer, Integer> mapNums = new HashMap<Integer,Integer>();
        for(int i=0; i< nums.length; ++i){
            if(mapNums.containsKey(target-nums[i])){
                return  new Integer[]{mapNums.get(target - nums[i]),i};
            }
            mapNums.put(nums[i],i);
        }
        return nums;
    }

    /**
     * 给定一个字符串，请你找出其中不含有重复字符的最长子串的长度。
     * @return
     */
    public  static  Integer lengthOfLongestSubstring(String str){
        if (str.length() == 0) return 0;
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
        int left = 0;
        int max = 0;
        for (int i = 0; i < str.length(); i++) {
            if (map.containsKey(str.charAt(i))) {
                left = Math.max(left, map.get(str.charAt(i)) + 1);
            }
            map.put(str.charAt(i), i);
            max = Math.max(max, i - left + 1);
        }
        return max;
    }

    /**
     * 返回字符串最长子串
     * @param str
     * @return
     */
    public  static  String StringSubtring(String str){
        if (str.length() == 0) return "";
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
        int left = 0;
        int max = 0;
        for (int i = 0; i < str.length(); i++) {
            if (map.containsKey(str.charAt(i))) {
                left = Math.max(left, map.get(str.charAt(i)) + 1);
            }
            map.put(str.charAt(i), i);
            max = Math.max(max, i - left + 1);
        }
        return str.substring(left-1,left+max-1);
    }

    /**
     * 给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
     * @return
     */
    public  static  Integer  reverseInteger(Integer num){
        if (num < Integer.MIN_VALUE) return 0;
        Integer ret = 0;
        Integer neg = num < 0 ? -1 : 1;
        num *= neg;
        while (num > 0) {
            Integer n = ret;
            n = ret;
            n *= 10;
            n += num % 10;
            num /= 10;
            if (n / 10 != ret) return 0;
            ret = n;
        }
        return ret * neg;
    }

    /**
     * 给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false
     * @return
     */
    public  static  Boolean palindromeInteger(Integer x){
        if (x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        }
        int revertedNumber = 0;
        while (x > revertedNumber) {
            revertedNumber = revertedNumber * 10 + x % 10;
            x /= 10;
        }
        return x == revertedNumber || x == revertedNumber / 10;
    }

    /**
     * 罗马数转整数
     * @return
     */
    public  static  Integer romanNumerals(String s){
        Integer size = s.length();
        Integer sum = 0;
        int i;
        for( i = 0; i<size-1;i++){
            sum  +=  getValue(s.charAt(i+1)) > getValue(s.charAt(i)) ? (-getValue(s.charAt(i))) :getValue(s.charAt(i));
        }
        sum += getValue(s.charAt(i));
        return  sum;
    }
    /**
     * 罗马数字对应整数表
     * @return
     */
    public static Integer getValue(char value){
        switch (value){
            case 'I':
                return 1;
            case 'V':
                return 5;
            case 'X':
                return 10;
            case 'L':
                return 50;
            case 'C':
                return 100;
            case 'D':
                return 500;
            case 'M':
                return 1000;
            default:
                return 0;
        }
    }

}
